Low density parity check (LDPC) code is a kind of linear block codes defined by very sparse parity matrix or bipartite graph, and since it is firstly discovered by Gallager, it is also called Gallager code. After decades of silence, with the development of computer hardware and the relative theory, MacKay and Neal rediscovered it and demonstrated that it has the property of approaching to the Shannon limit. The latest research shows that the LDPC code has the following advantages: LDPC code with a long code length can implement non-error transmission in the condition of extremely low signal to noise ratio, and it has the property of approaching to the Shannon limit; LDPC codes are usually decoded using BP algorithm, and the decoding complexity is proportional to the number of non-zero elements in the parity matrix, and the number of non-zero elements in the parity matrix is proportional to the code length, and thus for the LDPC with long code length, linear-time complexity decoding can be implemented and the approach to Shannon limit not only exists but also can be implemented; The BP algorithm has inherent parallelism, and thus it can be implemented with high parallel structure and can achieve very high decoding throughout.
The BP arithmetic uses the following log likelihood ratios:
            LLR      ⁡              (                  c          n                )              =          log      ⁢                        Pr          ⁡                      (                                          x                n                            =                                                +                  1                                ❘                                  y                  n                                                      )                                    Pr          ⁡                      (                                          x                n                            =                                                -                  1                                ❘                                  y                  n                                                      )                                          LLR      ⁡              (                  r          mn                )              =          log      ⁢                        r          mn          0                          r          mn          1                                LLR      ⁡              (                  q          mn                )              =          log      ⁢                        q          mn          0                          q          mn          1                                LLR      ⁡              (                  q          n                )              =          log      ⁢                        q          n          0                          q          n          1                    
And the standard BP algorithm in log domain specifically comprises:
(1) Initializing: initializing LLR (qmn) according to the following equation:
                    For        ⁢                                  ⁢        n            =      0        ,    …    ⁢                  ,          N      -      1                          ⁢                            For          ⁢                                          ⁢          m                =        0            ,      …      ⁢                          ,              M        -        1                                ⁢                  LLR        ⁡                  (                      q            mn                    )                    =                        log          ⁡                      (                                          q                mn                0                            /                              q                mn                1                                      )                          =                              LLR            ⁡                          (                              c                n                            )                                =                      2            ⁢                                          y                n                            /                              σ                2                                                                            ⁢    End    End
(2) Upgrading the check node: upgrading the LLR(rmn) according to the following equation:
                    For        ⁢                                  ⁢        m            =      0        ,    …    ⁢                  ,          M      -      1                          ⁢                  For        ⁢                                  ⁢        n            ∈              N        ⁡                  (          m          )                                        ⁢                  LLR        ⁡                  (                      r            mn                    )                    =                        (                                    ∏                                                n                  ′                                ∈                                                      N                    ⁡                                          (                      M                      )                                                        ⁢                  \                  ⁢                                                                          ⁢                  n                                                      ⁢                          α                              mn                ′                                              )                ⁢                  Φ          (                                    ∑                                                n                  ′                                ∈                                                      N                    ⁡                                          (                      M                      )                                                        ⁢                  \                  ⁢                                                                          ⁢                  n                                                      ⁢                          Φ              ⁡                              (                                  β                                      min                    ′                                                  )                                              )                                        ⁢    End    End
Where:
            α              min        ′              =          sign      ⁡              (                  LLR          ⁡                      (                          q                              mn                ′                                      )                          )                        β              min        ′              =                        LLR        ⁡                  (                      q                          mn              ′                                )                                      Φ      ⁡              (        x        )              =                  -                  log          ⁡                      (                          tanh              ⁡                              (                                  x                  /                  2                                )                                      )                              =              log        ⁢                                            ⅇ              x                        +            1                                              ⅇ              x                        -            1                              
(3) Updating the variable node: updating LLR(qmn) according to the following equation:
                    For        ⁢                                  ⁢        n            =      0        ,    …    ⁢                  ,          N      -      1                          ⁢                  For        ⁢                                  ⁢        m            ∈              M        ⁡                  (          n          )                                        ⁢                  LLR        ⁡                  (                      q            mn                    )                    =                        LLR          ⁡                      (                          c              n                        )                          +                              ∑                                          m                ′                            ∈                                                M                  ⁡                                      (                    n                    )                                                  ⁢                \                ⁢                                                                  ⁢                m                                              ⁢                      LLR            ⁡                          (                              r                                                      m                    ′                                    ⁢                  n                                            )                                                              ⁢    End    End
(4) Updating LLR(qn): updating LLR(qn) according to the following equation:
                    For        ⁢                                  ⁢        n            =      0        ,    …    ⁢                  ,          N      -      1                          ⁢                  LLR        ⁡                  (                      q            n                    )                    =                        LLR          ⁡                      (                          c              n                        )                          +                              ∑                          m              ∈                              M                ⁡                                  (                  n                  )                                                              ⁢                      LLR            ⁡                          (                              r                mn                            )                                            End
(5) Iteration termination judgment: performing hard decisions for the decoded output data according to the following equation:
                    For        ⁢                                  ⁢        n            =      0        ,    …    ⁢                  ,          N      -      1                          ⁢          If      ⁢                          ⁢              (                              LLR            ⁡                          (                              q                n                            )                                >          0                )                                ⁢                            x          ^                n            =      0                          ⁢    Else                      ⁢                            x          ^                n            =      1        End
In this step, if the condition of H{circumflex over (x)}T=0 is satisfied or the maximal number of iterations has been reached, terminating the whole decoding process, otherwise, proceeding to (2) to continue the process of iteration.
This standard BP algorithm iteratively decodes between the check node LLR(rmm) and the variable node LLR(qmm), in which, the number of iterations is relatively large, the calculation is relatively complicated, and for the mobile terminal, its silicon area and power cost are relatively large, thus not good for reducing the size of terminal and extending the using time of the battery.